{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b26bdf70-b1db-4a22-acf3-ee0391c21772",
   "metadata": {},
   "source": [
    "# Secret Agents: A Self-Healing Codebase Agentic Workflow\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "085a4cd9-ae03-4a15-b1e8-2ef1ab15770a",
   "metadata": {},
   "source": [
    "## Overview\n",
    "This code implements a workflow-based error detection and correction system that combines LangGraph, LLM capabilities, and vector database technology to detect runtime errors, generate fixes, and maintain a memory of bug patterns. The system takes function definitions and runtime arguments, processes them through a graph-based workflow, and maintains a hierarchical error management system enriched by vector-based similarity search."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "430b07f7-837a-484b-9c30-5c52c9d7df98",
   "metadata": {},
   "source": [
    "## Motivation\n",
    "Several key factors motivate this implementation:\n",
    "\n",
    "1. **Automated Error Resolution**\n",
    "   - Manual debugging is time-consuming and error-prone\n",
    "   - Automated fix generation streamlines the correction process\n",
    "   - LLMs can provide context-aware code repairs\n",
    "\n",
    "2. **Pattern-Based Learning**\n",
    "   - Vector databases enable similarity-based bug pattern recognition\n",
    "   - Previous fixes can inform future error resolution\n",
    "   - Semantic search capabilities improve fix relevance\n",
    "\n",
    "3. **Structured Bug Knowledge**\n",
    "   - Vector embeddings capture semantic relationships between errors\n",
    "   - ChromaDB enables efficient storage and retrieval of bug patterns\n",
    "   - Hierarchical error categorization through vector spaces\n",
    "\n",
    "4. **Runtime Code Modification**\n",
    "   - Safe deployment of generated fixes\n",
    "   - State tracking during modifications\n",
    "   - Validation of applied patches"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d550fa8-889d-4b28-9b2a-6fcdc5fef755",
   "metadata": {},
   "source": [
    "## Key Components\n",
    "1. **State Management System**: \n",
    "   - Maintains workflow state using Pydantic models\n",
    "   - Tracks function references, errors, and fixes\n",
    "   - Ensures type safety and execution validation\n",
    "\n",
    "2. **LLM Integration**: \n",
    "   - Leverages LLM for code analysis and generation\n",
    "   - Produces fixes based on error types:\n",
    "     - Runtime Errors\n",
    "     - Logic Errors\n",
    "     - Type Errors\n",
    "     - Resource Errors\n",
    "\n",
    "3. **Vector-Based Memory System**:\n",
    "   - Uses ChromaDB for efficient storage\n",
    "   - Enables semantic search of bug patterns\n",
    "   - Maintains contextual relationships between errors\n",
    "   - Supports pattern-based learning\n",
    "\n",
    "4. **Graph-based Workflow**: \n",
    "   - Uses LangGraph's StateGraph for orchestration\n",
    "   - Implements error detection nodes\n",
    "   - Controls fix generation through edges"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d79dbbe1-470e-434f-93d1-c77aa3eb237e",
   "metadata": {},
   "source": [
    "## Vector Databases and ChromaDB\n",
    "\n",
    "### What is a Vector Database?\n",
    "A vector database is specialized storage system designed to handle high-dimensional vectors, which are mathematical representations of data points. These vectors capture semantic meaning, making them ideal for:\n",
    "- Similarity search operations\n",
    "- Pattern recognition\n",
    "- Semantic relationships\n",
    "- Nearest neighbor queries\n",
    "\n",
    "### Why Vector DBs Matter for ML\n",
    "Vector databases are crucial for modern ML systems because they:\n",
    "1. Enable semantic search capabilities\n",
    "2. Support efficient similarity computations\n",
    "3. Scale well with large datasets\n",
    "4. Maintain context and relationships\n",
    "5. Facilitate pattern recognition\n",
    "\n",
    "### ChromaDB Implementation\n",
    "ChromaDB provides a lightweight, embedded vector database that offers:\n",
    "1. Simple API:\n",
    "```python\n",
    "chroma_client = chromadb.Client()\n",
    "collection = chroma_client.create_collection(name='bug-reports')\n",
    "```\n",
    "\n",
    "2. Easy Data Management:\n",
    "```python\n",
    "# Adding documents\n",
    "collection.add(\n",
    "    ids=[id],\n",
    "    documents=[document],\n",
    ")\n",
    "\n",
    "# Querying\n",
    "results = collection.query(\n",
    "    query_texts=[query],\n",
    "    n_results=10\n",
    ")\n",
    "```\n",
    "\n",
    "3. Automatic embedding generation\n",
    "4. Efficient similarity search\n",
    "5. Zero configuration requirements"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3748a00d-5303-41cf-b41b-d2c56fc41196",
   "metadata": {},
   "source": [
    "## Memory Architecture\n",
    "The system implements a sophisticated memory architecture:\n",
    "\n",
    "1. **Vector Storage**:\n",
    "   - Bug reports converted to embeddings\n",
    "   - Semantic relationships preserved\n",
    "   - Efficient similarity search\n",
    "\n",
    "2. **Pattern Recognition**:\n",
    "   - Similar bugs identified through vector similarity\n",
    "   - Historical fixes inform new solutions\n",
    "   - Pattern evolution tracked over time\n",
    "\n",
    "3. **Memory Updates**:\n",
    "   - New patterns integrated into existing knowledge\n",
    "   - Related patterns merged and refined\n",
    "   - Obsolete patterns pruned"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a37b3700-fb63-4d15-b740-9643210a4bc8",
   "metadata": {},
   "source": [
    "## Visual Overview\n",
    "A flowchart representing the design and flow of the workflow."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6114383f-c940-4b69-bc90-9912161ca0e7",
   "metadata": {},
   "source": [
    "<div style=\"max-width:600px;\">\n",
    "    \n",
    "![image.png](../images/self_healing_code.png)\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cf758b1-e1c3-499b-bf29-b51264d8d0be",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "This implementation demonstrates a practical approach to automated code healing, enhanced by vector database technology. The system combines graph-based workflow management with LLM capabilities and vector-based pattern recognition, allowing for structured error correction while maintaining clear process control.\n",
    "\n",
    "Key advantages include:\n",
    "- Automated error detection and correction\n",
    "- Semantic pattern recognition\n",
    "- Efficient similarity-based search\n",
    "- Safe runtime code modification\n",
    "\n",
    "Future improvements could focus on:\n",
    "- Enhanced embedding strategies\n",
    "- Multi-modal pattern recognition\n",
    "- Distributed vector storage\n",
    "- Advanced pattern evolution tracking\n",
    "\n",
    "This system provides a foundation for building more sophisticated self-healing systems, particularly in applications requiring runtime error correction and pattern learning, with the added benefit of efficient vector-based memory management through ChromaDB."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01726055-58e2-42f0-953d-50a58ef25544",
   "metadata": {},
   "source": [
    "# Dependencies and Imports\n",
    "Install dependencies and import libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4c6a6ae2-8687-4c70-82a7-34959555dcfb",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "\n",
    "!pip install langgraph\n",
    "!pip install langgraph-sdk\n",
    "!pip install langgraph-checkpoint-sqlite\n",
    "!pip install langchain-community\n",
    "!pip install langchain-core\n",
    "!pip install langchain-openai\n",
    "!pip install chromadb "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a851309b-b375-481d-bc58-f3fc314a1ed4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_core.prompts import ChatPromptTemplate\n",
    "from langgraph.graph import StateGraph, END\n",
    "from langchain.schema import HumanMessage\n",
    "from langchain_openai import ChatOpenAI\n",
    "\n",
    "import chromadb\n",
    "\n",
    "from pydantic import BaseModel\n",
    "from typing import Optional, Callable\n",
    "\n",
    "import uuid\n",
    "import json\n",
    "import os\n",
    "import types\n",
    "import inspect\n",
    "import sys\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "405fcf49-c87e-46e2-a3fc-1c8fde6d25fa",
   "metadata": {},
   "source": [
    "## Clients\n",
    "Import API keys and instantiate clients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bb54e70c-cc2e-4907-a240-758b2540f30d",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.environ['OPENAI_API_KEY'] = 'YOUR-API-KEY'\n",
    "llm = ChatOpenAI(model='gpt-4o-mini')\n",
    "\n",
    "chroma_client = chromadb.Client()\n",
    "collection = chroma_client.create_collection(name='bug-reports')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83900a95-a236-471b-bcc0-02d61b887b3b",
   "metadata": {},
   "source": [
    "## Define Agent State\n",
    "We'll define the state that our agent will maintain throughout its operation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0de61661-51b0-4ad3-b6f5-f3caa168d6c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class State(BaseModel):\n",
    "    function: Callable\n",
    "    function_string: str\n",
    "    arguments: list\n",
    "    error: bool\n",
    "    error_description: str = ''\n",
    "    new_function_string: str = ''\n",
    "    bug_report: str = ''\n",
    "    memory_search_results: list = []\n",
    "    memory_ids_to_update: list = []\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f35c846-3b39-42b8-9d51-b6c14d7de716",
   "metadata": {},
   "source": [
    "## Define Code Healing Node Functions\n",
    "Now we'll define the code healing node functions that our agent will use: code_execution_node, code_update_node and code_patching_node.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "596ffc4a-bb83-45ae-8ab8-e162bb566af9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def code_execution_node(state: State):\n",
    "    ''' Run Arbitrary Code '''\n",
    "    try:\n",
    "        print('\\nRunning Arbitrary Function')\n",
    "        print('--------------------------\\n')\n",
    "        result = state.function(*state.arguments)\n",
    "        print('\\n✅ Arbitrary Function Ran Without Error')\n",
    "        print(f'Result: {result}')\n",
    "        print('---------------------------------------\\n')\n",
    "    except Exception as e:\n",
    "        print(f'❌ Function Raised an Error: {e}')\n",
    "        state.error = True\n",
    "        state.error_description = str(e)\n",
    "    return state\n",
    "\n",
    "\n",
    "def code_update_node(state: State):\n",
    "    ''' Update Arbitratry Code '''\n",
    "    prompt = ChatPromptTemplate.from_template(\n",
    "        'You are tasked with fixing a Python function that raised an error.'\n",
    "        'Function: {function_string}'\n",
    "        'Error: {error_description}' \n",
    "        'You must provide a fix for the present error only.'\n",
    "        'The bug fix should handle the thrown error case gracefully by returning an error message.'\n",
    "        'Do not raise an error in your bug fix.'\n",
    "        'The function must use the exact same name and parameters.'\n",
    "        'Your response must contain only the function definition with no additional text.'\n",
    "        'Your response must not contain any additional formatting, such as code delimiters or language declarations.'\n",
    "    )\n",
    "    message = HumanMessage(content=prompt.format(function_string=state.function_string, error_description=state.error_description))\n",
    "    new_function_string = llm.invoke([message]).content.strip()\n",
    "\n",
    "    print('\\n🐛 Buggy Function')\n",
    "    print('-----------------\\n')\n",
    "    print(state.function_string)\n",
    "    print('\\n🩹 Proposed Bug Fix')\n",
    "    print('-------------------\\n')\n",
    "    print(new_function_string)\n",
    "    \n",
    "    state.new_function_string = new_function_string\n",
    "    return state\n",
    "\n",
    "\n",
    "def code_patching_node(state: State):\n",
    "    ''' Fix Arbitrary Code '''\n",
    "    try:\n",
    "        print('\\n*******************')\n",
    "        print('\\n❤️‍🩹 Patching code...')\n",
    "        # Store the new function as a string\n",
    "        new_code = state.new_function_string\n",
    "        \n",
    "        # Create namespace for new function\n",
    "        namespace = {}\n",
    "        \n",
    "        # Execute new code in namespace\n",
    "        exec(new_code, namespace)\n",
    "        \n",
    "        # Get function name dynamically\n",
    "        func_name = state.function.__name__\n",
    "        \n",
    "        # Get the new function using dynamic name\n",
    "        new_function = namespace[func_name]\n",
    "        \n",
    "        # Update state\n",
    "        state.function = new_function\n",
    "        state.error = False\n",
    "\n",
    "        # Test the new function\n",
    "        result = state.function(*state.arguments)\n",
    "\n",
    "        print('...patch complete 😬\\n')\n",
    "                \n",
    "    except Exception as e:\n",
    "        print(f'...patch failed: {e}')\n",
    "        print(f'Error details: {str(e)}')\n",
    "\n",
    "    print('******************\\n')\n",
    "    return state"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "747892fd-9e10-490b-a0ee-d8aadb2eebb0",
   "metadata": {},
   "source": [
    "## Define Bug Reporting Node Functions\n",
    "Now we'll define the bug reporting node functions that our agent will use: bug_report_node, memory_search_node, memory_generation_node and memory_modification_node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7b4d829b-ec81-425a-a38c-819b63c1fe18",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bug_report_node(state: State):\n",
    "    ''' Generate Bug Report '''\n",
    "    prompt = ChatPromptTemplate.from_template(\n",
    "        'You are tasked with generating a bug report for a Python function that raised an error.'\n",
    "        'Function: {function_string}'\n",
    "        'Error: {error_description}'\n",
    "        'Your response must be a comprehensive string including only crucial information on the bug report'\n",
    "    )\n",
    "    message = HumanMessage(content=prompt.format(function_string=state.function_string, error_description=state.error_description))\n",
    "    bug_report = llm.invoke([message]).content.strip()\n",
    "\n",
    "    print('\\n📝 Generating Bug Report')\n",
    "    print('------------------------\\n')\n",
    "    print(bug_report)\n",
    "\n",
    "    state.bug_report = bug_report\n",
    "    return state\n",
    "\n",
    "\n",
    "# Digest the bug report using the same template used when saving bug reports to increase the accuracy and relevance of results when querying the vector database.\n",
    "def memory_search_node(state: State):\n",
    "    ''' Find memories relevant to the current bug report '''\n",
    "    prompt = ChatPromptTemplate.from_template(\n",
    "        'You are tasked with archiving a bug report for a Python function that raised an error.'\n",
    "        'Bug Report: {bug_report}.'\n",
    "        'Your response must be a concise string including only crucial information on the bug report for future reference.'\n",
    "        'Format: # function_name ## error_description ### error_analysis'\n",
    "    )\n",
    "    \n",
    "    message = HumanMessage(content=prompt.format(\n",
    "        bug_report=state.bug_report,\n",
    "    ))\n",
    "    \n",
    "    response = llm.invoke([message]).content.strip()\n",
    "\n",
    "    results = collection.query(query_texts=[response])\n",
    "\n",
    "    print('\\n🔎 Searching bug reports...')\n",
    "    if results['ids'][0]:\n",
    "        print(f'...{len(results[\"ids\"][0])} found.\\n')\n",
    "        print(results)\n",
    "        state.memory_search_results = [{'id':results['ids'][0][index], 'memory':results['documents'][0][index], 'distance':results['distances'][0][index]} for index, id in enumerate(results['ids'][0])]\n",
    "    else:\n",
    "        print('...none found.\\n')\n",
    "            \n",
    "    return state\n",
    "\n",
    "\n",
    "# Filter the top 30% of results to ensure the relevance of memories being updated.\n",
    "def memory_filter_node(state: State):\n",
    "    print('\\n🗑️ Filtering bug reports...')\n",
    "    for memory in state.memory_search_results:\n",
    "        if memory['distance'] < 0.3:\n",
    "            state.memory_ids_to_update.append(memory['id'])\n",
    "        \n",
    "    if state.memory_ids_to_update:\n",
    "        print(f'...{len(state.memory_ids_to_update)} selected.\\n')\n",
    "    else:\n",
    "        print('...none selected.\\n')\n",
    "            \n",
    "    return state\n",
    "\n",
    "\n",
    "# Condense the bug report before storing it in the vector database.\n",
    "def memory_generation_node(state: State):\n",
    "    ''' Generate relevant memories based on new bug report '''\n",
    "    prompt = ChatPromptTemplate.from_template(\n",
    "        'You are tasked with archiving a bug report for a Python function that raised an error.'\n",
    "        'Bug Report: {bug_report}.'\n",
    "        'Your response must be a concise string including only crucial information on the bug report for future reference.'\n",
    "        'Format: # function_name ## error_description ### error_analysis'\n",
    "    )\n",
    "    \n",
    "    message = HumanMessage(content=prompt.format(\n",
    "        bug_report=state.bug_report,\n",
    "    ))\n",
    "    \n",
    "    response = llm.invoke([message]).content.strip()\n",
    "\n",
    "    print('\\n💾 Saving Bug Report to Memory')\n",
    "    print('------------------------------\\n')\n",
    "    print(response)\n",
    "\n",
    "    id = str(uuid.uuid4())\n",
    "    collection.add(\n",
    "        ids=[id],\n",
    "        documents=[response],\n",
    "    )        \n",
    "    return state\n",
    "\n",
    "\n",
    "# Use the prior memory as well as the current bug report to generate an updated version of it.\n",
    "def memory_modification_node(state: State):\n",
    "    ''' Modify relevant memories based on new interaction '''\n",
    "    prompt = ChatPromptTemplate.from_template(\n",
    "        'Update the following memories based on the new interaction:'\n",
    "        'Current Bug Report: {bug_report}'\n",
    "        'Prior Bug Report: {memory_to_update}'\n",
    "        'Your response must be a concise but cumulative string including only crucial information on the current and prior bug reports for future reference.'\n",
    "        'Format: # function_name ## error_description ### error_analysis'\n",
    "    )\n",
    "    memory_to_update_id = state.memory_ids_to_update.pop(0)\n",
    "    state.memory_search_results.pop(0)\n",
    "    results = collection.get(ids=[memory_to_update_id])\n",
    "    memory_to_update = results['documents'][0]\n",
    "    message = HumanMessage(content=prompt.format(\n",
    "        bug_report=state.bug_report,\n",
    "        memory_to_update=memory_to_update,\n",
    "    ))\n",
    "    \n",
    "    response = llm.invoke([message]).content.strip()\n",
    "    \n",
    "    print('\\nCurrent Bug Report')\n",
    "    print('------------------\\n')\n",
    "    print(memory_to_update)\n",
    "    print('\\nWill be Replaced With')\n",
    "    print('---------------------\\n')\n",
    "    print(response)\n",
    "    \n",
    "    collection.update(\n",
    "        ids=[memory_to_update_id],\n",
    "        documents=[response],\n",
    "    )\n",
    "        \n",
    "    return state\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65fe049c-efda-4cc9-aa81-44b8fc534434",
   "metadata": {},
   "source": [
    "## Define Edge Functions\n",
    "Now we'll define the conditional edge function that our agent will use to control the workflow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "898b3b42-9475-45d1-b517-26a889ff6687",
   "metadata": {},
   "outputs": [],
   "source": [
    "def error_router(state: State):\n",
    "    if state.error:\n",
    "        return 'bug_report_node'\n",
    "    else:\n",
    "        return END\n",
    "\n",
    "def memory_filter_router(state: State):\n",
    "    if state.memory_search_results:\n",
    "        return 'memory_filter_node'\n",
    "    else:\n",
    "        return 'memory_generation_node'\n",
    "\n",
    "\n",
    "def memory_generation_router(state: State):\n",
    "    if state.memory_ids_to_update:\n",
    "        return 'memory_modification_node'\n",
    "    else:\n",
    "        return 'memory_generation_node'\n",
    "\n",
    "\n",
    "def memory_update_router(state: State):\n",
    "    if state.memory_ids_to_update:\n",
    "        return 'memory_modification_node'\n",
    "    else:\n",
    "        return 'code_update_node'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14b4075e-b6f4-4410-a7ec-8405000984d1",
   "metadata": {},
   "source": [
    "## Build Workflow\n",
    "Now we'll create our workflow and compile it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b3fafb0c-8e75-4b1c-99d0-64978b40a45e",
   "metadata": {},
   "outputs": [],
   "source": [
    "builder = StateGraph(State)\n",
    "\n",
    "# Add nodes to the graph\n",
    "builder.add_node('code_execution_node', code_execution_node)\n",
    "builder.add_node('code_update_node', code_update_node)\n",
    "builder.add_node('code_patching_node', code_patching_node)\n",
    "builder.add_node('bug_report_node', bug_report_node)\n",
    "builder.add_node('memory_search_node', memory_search_node)\n",
    "builder.add_node('memory_filter_node', memory_filter_node)\n",
    "builder.add_node('memory_modification_node', memory_modification_node)\n",
    "builder.add_node('memory_generation_node', memory_generation_node)\n",
    "\n",
    "\n",
    "# Add edges to the graph\n",
    "builder.set_entry_point('code_execution_node')\n",
    "builder.add_conditional_edges('code_execution_node', error_router)\n",
    "builder.add_edge('bug_report_node', 'memory_search_node')\n",
    "builder.add_conditional_edges('memory_search_node', memory_filter_router)\n",
    "builder.add_conditional_edges('memory_filter_node', memory_generation_router)\n",
    "builder.add_edge('memory_generation_node', 'code_update_node')\n",
    "builder.add_conditional_edges('memory_modification_node', memory_update_router)\n",
    "\n",
    "builder.add_edge('code_update_node', 'code_patching_node')\n",
    "builder.add_edge('code_patching_node', 'code_execution_node')\n",
    "\n",
    "# Compile the graph\n",
    "graph = builder.compile()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba4fec8a-1b6d-4f2a-8d49-b31ba55122dc",
   "metadata": {},
   "source": [
    "# Main Function\n",
    "Define the function that runs the instanciates the workflow and its state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "465b71e0-3aca-4e66-a240-5886b29792fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def execute_self_healing_code_system(function, arguments):\n",
    "\n",
    "    state = State(\n",
    "        error=False,\n",
    "        function=function,\n",
    "        function_string=inspect.getsource(function),\n",
    "        arguments=arguments,\n",
    "    )\n",
    "    \n",
    "    return graph.invoke(state)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7dc740e-322a-444f-8140-8e72b2c71160",
   "metadata": {},
   "source": [
    "# Run Program\n",
    "Instanciate the main function and observe outputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9b19f3af-cc4c-4201-bc3b-15588c112ea4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*******************************\n",
      "*******************************\n",
      "** Testing Division Function **\n",
      "*******************************\n",
      "*******************************\n",
      "\n",
      "Running Arbitrary Function\n",
      "--------------------------\n",
      "\n",
      "❌ Function Raised an Error: division by zero\n",
      "\n",
      "📝 Generating Bug Report\n",
      "------------------------\n",
      "\n",
      "**Bug Report**\n",
      "\n",
      "**Function Name:** `divide_two_numbers`\n",
      "\n",
      "**Description:** The function attempts to divide two numbers, `a` and `b`. However, it raises a `ZeroDivisionError` when `b` is zero.\n",
      "\n",
      "**Error Message:** `division by zero`\n",
      "\n",
      "**Steps to Reproduce:**\n",
      "1. Call the function with any number for `a`.\n",
      "2. Pass `0` as the value for `b`.\n",
      "\n",
      "**Example:**\n",
      "```python\n",
      "divide_two_numbers(10, 0)  # Raises ZeroDivisionError\n",
      "```\n",
      "\n",
      "**Expected Behavior:** The function should handle the case where `b` is zero and return a user-friendly error message or a default value instead of raising an exception.\n",
      "\n",
      "**Proposed Solution:** Implement error handling to check if `b` is zero before performing the division. Return an appropriate message or value in such cases. \n",
      "\n",
      "**Priority:** High\n",
      "\n",
      "🔎 Searching bug reports...\n",
      "...none found.\n",
      "\n",
      "\n",
      "💾 Saving Bug Report to Memory\n",
      "------------------------------\n",
      "\n",
      "# divide_two_numbers ## ZeroDivisionError when b is zero ### Function lacks error handling for division by zero, leading to unhandled exceptions.\n",
      "\n",
      "🐛 Buggy Function\n",
      "-----------------\n",
      "\n",
      "def divide_two_numbers(a, b):\n",
      "    return a/b\n",
      "\n",
      "\n",
      "🩹 Proposed Bug Fix\n",
      "-------------------\n",
      "\n",
      "def divide_two_numbers(a, b):\n",
      "    if b == 0:\n",
      "        return \"Error: Division by zero is not allowed.\"\n",
      "    return a / b\n",
      "\n",
      "*******************\n",
      "\n",
      "❤️‍🩹 Patching code...\n",
      "...patch complete 😬\n",
      "\n",
      "******************\n",
      "\n",
      "\n",
      "Running Arbitrary Function\n",
      "--------------------------\n",
      "\n",
      "\n",
      "✅ Arbitrary Function Ran Without Error\n",
      "Result: Error: Division by zero is not allowed.\n",
      "---------------------------------------\n",
      "\n",
      "\n",
      "Running Arbitrary Function\n",
      "--------------------------\n",
      "\n",
      "❌ Function Raised an Error: unsupported operand type(s) for /: 'str' and 'int'\n",
      "\n",
      "📝 Generating Bug Report\n",
      "------------------------\n",
      "\n",
      "**Bug Report: Division Function Error**\n",
      "\n",
      "**Function:** `divide_two_numbers(a, b)`\n",
      "\n",
      "**Error Raised:** `unsupported operand type(s) for /: 'str' and 'int'`\n",
      "\n",
      "**Description:** The function `divide_two_numbers` fails to handle cases where the first argument `a` is of type `str` while the second argument `b` is of type `int`. This leads to a TypeError when attempting to perform division.\n",
      "\n",
      "**Steps to Reproduce:**\n",
      "1. Call the function with a string as the first argument and an integer as the second argument. \n",
      "   Example: `divide_two_numbers(\"10\", 2)`\n",
      "\n",
      "**Expected Behavior:** The function should either handle the type mismatch gracefully (e.g., by raising a custom error or converting input types) or document the expected input types clearly.\n",
      "\n",
      "**Actual Behavior:** The function raises a TypeError, disrupting execution.\n",
      "\n",
      "**Suggested Fix:** Implement input type validation to ensure both arguments are numeric (int or float) before performing the division. Alternatively, consider converting input types as needed.\n",
      "\n",
      "**Priority:** Medium\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Number of requested results 10 is greater than number of elements in index 1, updating n_results = 1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "🔎 Searching bug reports...\n",
      "...1 found.\n",
      "\n",
      "{'ids': [['ce0ad0e0-1716-4ff6-bdc3-4f3d80431811']], 'embeddings': None, 'documents': [['# divide_two_numbers ## ZeroDivisionError when b is zero ### Function lacks error handling for division by zero, leading to unhandled exceptions.']], 'uris': None, 'data': None, 'metadatas': [[None]], 'distances': [[0.5218325257301331]], 'included': [<IncludeEnum.distances: 'distances'>, <IncludeEnum.documents: 'documents'>, <IncludeEnum.metadatas: 'metadatas'>]}\n",
      "\n",
      "🗑️ Filtering bug reports...\n",
      "...none selected.\n",
      "\n",
      "\n",
      "💾 Saving Bug Report to Memory\n",
      "------------------------------\n",
      "\n",
      "# divide_two_numbers ## unsupported operand type(s) for /: 'str' and 'int' ### Function fails to handle type mismatch between string and integer inputs, leading to TypeError during division.\n",
      "\n",
      "🐛 Buggy Function\n",
      "-----------------\n",
      "\n",
      "def divide_two_numbers(a, b):\n",
      "    return a/b\n",
      "\n",
      "\n",
      "🩹 Proposed Bug Fix\n",
      "-------------------\n",
      "\n",
      "def divide_two_numbers(a, b):\n",
      "    if isinstance(a, str) or isinstance(b, str):\n",
      "        return \"Error: unsupported operand type(s) for /: 'str' and 'int'\"\n",
      "    return a / b\n",
      "\n",
      "*******************\n",
      "\n",
      "❤️‍🩹 Patching code...\n",
      "...patch complete 😬\n",
      "\n",
      "******************\n",
      "\n",
      "\n",
      "Running Arbitrary Function\n",
      "--------------------------\n",
      "\n",
      "\n",
      "✅ Arbitrary Function Ran Without Error\n",
      "Result: Error: unsupported operand type(s) for /: 'str' and 'int'\n",
      "---------------------------------------\n",
      "\n",
      "**************************************\n",
      "**************************************\n",
      "** Testing List Processing Function **\n",
      "**************************************\n",
      "**************************************\n",
      "\n",
      "Running Arbitrary Function\n",
      "--------------------------\n",
      "\n",
      "❌ Function Raised an Error: list index out of range\n",
      "\n",
      "📝 Generating Bug Report\n",
      "------------------------\n",
      "\n",
      "Bug Report: \n",
      "\n",
      "**Function Name:** process_list  \n",
      "**Parameters:** lst (list), index (int)  \n",
      "**Error Raised:** IndexError: list index out of range  \n",
      "**Description:** The function attempts to access an element at a specified index in the list `lst`, but if the index is greater than or equal to the length of the list or if the list is empty, it raises an \"IndexError\".  \n",
      "**Reproduction Steps:**  \n",
      "1. Call `process_list([], 0)`  \n",
      "2. Call `process_list([1, 2, 3], 5)`  \n",
      "**Expected Behavior:** The function should handle invalid indices gracefully, possibly by returning a default value or raising a custom error message.  \n",
      "**Priority:** High - this bug can lead to runtime errors when the function is used with invalid inputs.  \n",
      "**Proposed Solution:** Implement index validation before accessing the list element.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Number of requested results 10 is greater than number of elements in index 2, updating n_results = 2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "🔎 Searching bug reports...\n",
      "...2 found.\n",
      "\n",
      "{'ids': [['ce0ad0e0-1716-4ff6-bdc3-4f3d80431811', '3dae16c1-6991-4267-9c88-fd3a86330963']], 'embeddings': None, 'documents': [['# divide_two_numbers ## ZeroDivisionError when b is zero ### Function lacks error handling for division by zero, leading to unhandled exceptions.', \"# divide_two_numbers ## unsupported operand type(s) for /: 'str' and 'int' ### Function fails to handle type mismatch between string and integer inputs, leading to TypeError during division.\"]], 'uris': None, 'data': None, 'metadatas': [[None, None]], 'distances': [[1.1425693035125732, 1.1896761655807495]], 'included': [<IncludeEnum.distances: 'distances'>, <IncludeEnum.documents: 'documents'>, <IncludeEnum.metadatas: 'metadatas'>]}\n",
      "\n",
      "🗑️ Filtering bug reports...\n",
      "...none selected.\n",
      "\n",
      "\n",
      "💾 Saving Bug Report to Memory\n",
      "------------------------------\n",
      "\n",
      "# process_list ## IndexError: list index out of range ### The function does not validate the index before accessing the list, leading to potential runtime errors with invalid inputs.\n",
      "\n",
      "🐛 Buggy Function\n",
      "-----------------\n",
      "\n",
      "def process_list(lst, index):\n",
      "    return lst[index] * 2\n",
      "\n",
      "\n",
      "🩹 Proposed Bug Fix\n",
      "-------------------\n",
      "\n",
      "def process_list(lst, index):\n",
      "    if index < 0 or index >= len(lst):\n",
      "        return \"Error: Index out of range\"\n",
      "    return lst[index] * 2\n",
      "\n",
      "*******************\n",
      "\n",
      "❤️‍🩹 Patching code...\n",
      "...patch complete 😬\n",
      "\n",
      "******************\n",
      "\n",
      "\n",
      "Running Arbitrary Function\n",
      "--------------------------\n",
      "\n",
      "\n",
      "✅ Arbitrary Function Ran Without Error\n",
      "Result: Error: Index out of range\n",
      "---------------------------------------\n",
      "\n",
      "\n",
      "Running Arbitrary Function\n",
      "--------------------------\n",
      "\n",
      "❌ Function Raised an Error: 'NoneType' object is not subscriptable\n",
      "\n",
      "📝 Generating Bug Report\n",
      "------------------------\n",
      "\n",
      "**Bug Report:**\n",
      "\n",
      "**Function:** `process_list(lst, index)`\n",
      "\n",
      "**Error Raised:** `'NoneType' object is not subscriptable`\n",
      "\n",
      "**Description:** The function attempts to access an element of `lst` using the provided `index`. If `lst` is `None`, this results in a TypeError since `NoneType` does not support indexing.\n",
      "\n",
      "**Steps to Reproduce:**\n",
      "1. Call `process_list(None, 0)`.\n",
      "2. Observe the error message.\n",
      "\n",
      "**Expected Behavior:** The function should handle cases where `lst` is `None` gracefully, either by returning a default value or raising a more informative error.\n",
      "\n",
      "**Proposed Fix:** Add a check at the beginning of the function to ensure `lst` is not `None`. For example:\n",
      "\n",
      "```python\n",
      "def process_list(lst, index):\n",
      "    if lst is None:\n",
      "        raise ValueError(\"Input list cannot be None\")\n",
      "    return lst[index] * 2\n",
      "```\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Number of requested results 10 is greater than number of elements in index 3, updating n_results = 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "🔎 Searching bug reports...\n",
      "...3 found.\n",
      "\n",
      "{'ids': [['128e20ca-8f3b-4d9f-aa4c-3c9e6a936532', 'ce0ad0e0-1716-4ff6-bdc3-4f3d80431811', '3dae16c1-6991-4267-9c88-fd3a86330963']], 'embeddings': None, 'documents': [['# process_list ## IndexError: list index out of range ### The function does not validate the index before accessing the list, leading to potential runtime errors with invalid inputs.', '# divide_two_numbers ## ZeroDivisionError when b is zero ### Function lacks error handling for division by zero, leading to unhandled exceptions.', \"# divide_two_numbers ## unsupported operand type(s) for /: 'str' and 'int' ### Function fails to handle type mismatch between string and integer inputs, leading to TypeError during division.\"]], 'uris': None, 'data': None, 'metadatas': [[None, None, None]], 'distances': [[0.5496565103530884, 1.4135934114456177, 1.4512107372283936]], 'included': [<IncludeEnum.distances: 'distances'>, <IncludeEnum.documents: 'documents'>, <IncludeEnum.metadatas: 'metadatas'>]}\n",
      "\n",
      "🗑️ Filtering bug reports...\n",
      "...none selected.\n",
      "\n",
      "\n",
      "💾 Saving Bug Report to Memory\n",
      "------------------------------\n",
      "\n",
      "# process_list ## 'NoneType' object is not subscriptable ### Function fails when lst is None, leading to TypeError; should validate input and handle None case.\n",
      "\n",
      "🐛 Buggy Function\n",
      "-----------------\n",
      "\n",
      "def process_list(lst, index):\n",
      "    return lst[index] * 2\n",
      "\n",
      "\n",
      "🩹 Proposed Bug Fix\n",
      "-------------------\n",
      "\n",
      "def process_list(lst, index):\n",
      "    if lst is None:\n",
      "        return \"Error: Provided list is None.\"\n",
      "    return lst[index] * 2\n",
      "\n",
      "*******************\n",
      "\n",
      "❤️‍🩹 Patching code...\n",
      "...patch complete 😬\n",
      "\n",
      "******************\n",
      "\n",
      "\n",
      "Running Arbitrary Function\n",
      "--------------------------\n",
      "\n",
      "\n",
      "✅ Arbitrary Function Ran Without Error\n",
      "Result: Error: Provided list is None.\n",
      "---------------------------------------\n",
      "\n",
      "***********************************\n",
      "***********************************\n",
      "** Testing Date Parsing Function **\n",
      "***********************************\n",
      "***********************************\n",
      "\n",
      "Running Arbitrary Function\n",
      "--------------------------\n",
      "\n",
      "❌ Function Raised an Error: not enough values to unpack (expected 3, got 1)\n",
      "\n",
      "📝 Generating Bug Report\n",
      "------------------------\n",
      "\n",
      "**Bug Report: parse_date Function**\n",
      "\n",
      "**Function Name:** parse_date  \n",
      "**Error Raised:** ValueError: not enough values to unpack (expected 3, got 1)  \n",
      "**Description:** The function attempts to split the input string `date_string` by the '-' character and unpack the result into three variables: year, month, and day. However, if the input string does not contain two '-' characters, it raises a ValueError due to insufficient values for unpacking.  \n",
      "**Reproduction Steps:**  \n",
      "1. Call `parse_date(\"2023\")` or any string that does not contain exactly two '-' characters.\n",
      "2. Observe the error message indicating that not enough values were provided for unpacking.  \n",
      "**Expected Behavior:** The function should handle cases where the input does not conform to the expected format, either by returning an error message or raising a custom exception.  \n",
      "**Suggested Fix:** Implement input validation to ensure the `date_string` contains the correct format (YYYY-MM-DD) before attempting to unpack the values.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Number of requested results 10 is greater than number of elements in index 4, updating n_results = 4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "🔎 Searching bug reports...\n",
      "...4 found.\n",
      "\n",
      "{'ids': [['3dae16c1-6991-4267-9c88-fd3a86330963', '128e20ca-8f3b-4d9f-aa4c-3c9e6a936532', '576b4c4a-95dc-4936-8b8c-424962db4940', 'ce0ad0e0-1716-4ff6-bdc3-4f3d80431811']], 'embeddings': None, 'documents': [[\"# divide_two_numbers ## unsupported operand type(s) for /: 'str' and 'int' ### Function fails to handle type mismatch between string and integer inputs, leading to TypeError during division.\", '# process_list ## IndexError: list index out of range ### The function does not validate the index before accessing the list, leading to potential runtime errors with invalid inputs.', \"# process_list ## 'NoneType' object is not subscriptable ### Function fails when lst is None, leading to TypeError; should validate input and handle None case.\", '# divide_two_numbers ## ZeroDivisionError when b is zero ### Function lacks error handling for division by zero, leading to unhandled exceptions.']], 'uris': None, 'data': None, 'metadatas': [[None, None, None, None]], 'distances': [[1.0926787853240967, 1.1112380027770996, 1.1864970922470093, 1.275838851928711]], 'included': [<IncludeEnum.distances: 'distances'>, <IncludeEnum.documents: 'documents'>, <IncludeEnum.metadatas: 'metadatas'>]}\n",
      "\n",
      "🗑️ Filtering bug reports...\n",
      "...none selected.\n",
      "\n",
      "\n",
      "💾 Saving Bug Report to Memory\n",
      "------------------------------\n",
      "\n",
      "# parse_date ## ValueError: not enough values to unpack (expected 3, got 1) ### The function fails when the input string does not contain exactly two '-' characters, leading to insufficient values for unpacking. Input validation is needed to ensure correct format (YYYY-MM-DD).\n",
      "\n",
      "🐛 Buggy Function\n",
      "-----------------\n",
      "\n",
      "def parse_date(date_string):\n",
      "    year, month, day = date_string.split('-')\n",
      "    return {'year': int(year), 'month': int(month), 'day': int(day)}\n",
      "\n",
      "\n",
      "🩹 Proposed Bug Fix\n",
      "-------------------\n",
      "\n",
      "def parse_date(date_string):\n",
      "    parts = date_string.split('-')\n",
      "    if len(parts) != 3:\n",
      "        return \"Error: Input must be in 'YYYY-MM-DD' format\"\n",
      "    year, month, day = parts\n",
      "    return {'year': int(year), 'month': int(month), 'day': int(day)}\n",
      "\n",
      "*******************\n",
      "\n",
      "❤️‍🩹 Patching code...\n",
      "...patch complete 😬\n",
      "\n",
      "******************\n",
      "\n",
      "\n",
      "Running Arbitrary Function\n",
      "--------------------------\n",
      "\n",
      "\n",
      "✅ Arbitrary Function Ran Without Error\n",
      "Result: Error: Input must be in 'YYYY-MM-DD' format\n",
      "---------------------------------------\n",
      "\n",
      "\n",
      "Running Arbitrary Function\n",
      "--------------------------\n",
      "\n",
      "❌ Function Raised an Error: invalid literal for int() with base 10: 'abc'\n",
      "\n",
      "📝 Generating Bug Report\n",
      "------------------------\n",
      "\n",
      "**Bug Report: Invalid Input Handling in parse_date Function**\n",
      "\n",
      "**Function:** `parse_date(date_string)`\n",
      "\n",
      "**Error Encountered:** `ValueError: invalid literal for int() with base 10: 'abc'`\n",
      "\n",
      "**Description:** The function `parse_date` is designed to parse a date string in the format `YYYY-MM-DD`. However, it does not handle invalid input properly. When provided with a date string that contains non-numeric characters (e.g., 'abc' instead of valid year, month, or day values), the function raises a `ValueError` when attempting to convert the string to an integer.\n",
      "\n",
      "**Steps to Reproduce:**\n",
      "1. Call `parse_date('abc-def-ghi')`\n",
      "2. Observe the error raised.\n",
      "\n",
      "**Expected Behavior:** The function should validate the input string and handle errors gracefully, either by raising a custom error or returning a specific message indicating the issue with the input format.\n",
      "\n",
      "**Proposed Solution:** Implement input validation to check if the split components of the date string are numeric before converting them to integers. If the input is invalid, return an informative error message.\n",
      "\n",
      "**Priority:** High, as this affects the function's usability with invalid inputs.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Number of requested results 10 is greater than number of elements in index 5, updating n_results = 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "🔎 Searching bug reports...\n",
      "...5 found.\n",
      "\n",
      "{'ids': [['df6c880a-9135-4a0e-887e-692a1a545575', '3dae16c1-6991-4267-9c88-fd3a86330963', '128e20ca-8f3b-4d9f-aa4c-3c9e6a936532', '576b4c4a-95dc-4936-8b8c-424962db4940', 'ce0ad0e0-1716-4ff6-bdc3-4f3d80431811']], 'embeddings': None, 'documents': [[\"# parse_date ## ValueError: not enough values to unpack (expected 3, got 1) ### The function fails when the input string does not contain exactly two '-' characters, leading to insufficient values for unpacking. Input validation is needed to ensure correct format (YYYY-MM-DD).\", \"# divide_two_numbers ## unsupported operand type(s) for /: 'str' and 'int' ### Function fails to handle type mismatch between string and integer inputs, leading to TypeError during division.\", '# process_list ## IndexError: list index out of range ### The function does not validate the index before accessing the list, leading to potential runtime errors with invalid inputs.', \"# process_list ## 'NoneType' object is not subscriptable ### Function fails when lst is None, leading to TypeError; should validate input and handle None case.\", '# divide_two_numbers ## ZeroDivisionError when b is zero ### Function lacks error handling for division by zero, leading to unhandled exceptions.']], 'uris': None, 'data': None, 'metadatas': [[None, None, None, None, None]], 'distances': [[0.3664924204349518, 0.9500781893730164, 1.1277501583099365, 1.2307831048965454, 1.242687702178955]], 'included': [<IncludeEnum.distances: 'distances'>, <IncludeEnum.documents: 'documents'>, <IncludeEnum.metadatas: 'metadatas'>]}\n",
      "\n",
      "🗑️ Filtering bug reports...\n",
      "...none selected.\n",
      "\n",
      "\n",
      "💾 Saving Bug Report to Memory\n",
      "------------------------------\n",
      "\n",
      "# parse_date ## ValueError: invalid literal for int() with base 10: 'abc' ### The function lacks input validation, causing it to raise an error when non-numeric characters are present in the date string. Implementing checks for numeric values before conversion is necessary to improve usability.\n",
      "\n",
      "🐛 Buggy Function\n",
      "-----------------\n",
      "\n",
      "def parse_date(date_string):\n",
      "    year, month, day = date_string.split('-')\n",
      "    return {'year': int(year), 'month': int(month), 'day': int(day)}\n",
      "\n",
      "\n",
      "🩹 Proposed Bug Fix\n",
      "-------------------\n",
      "\n",
      "def parse_date(date_string):\n",
      "    try:\n",
      "        year, month, day = date_string.split('-')\n",
      "        return {'year': int(year), 'month': int(month), 'day': int(day)}\n",
      "    except ValueError:\n",
      "        return \"Error: invalid date format\"\n",
      "\n",
      "*******************\n",
      "\n",
      "❤️‍🩹 Patching code...\n",
      "...patch complete 😬\n",
      "\n",
      "******************\n",
      "\n",
      "\n",
      "Running Arbitrary Function\n",
      "--------------------------\n",
      "\n",
      "\n",
      "✅ Arbitrary Function Ran Without Error\n",
      "Result: Error: invalid date format\n",
      "---------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Test Function 1: List Processing\n",
    "def process_list(lst, index):\n",
    "    return lst[index] * 2\n",
    "\n",
    "# Test Function 2: String Parsing\n",
    "def parse_date(date_string):\n",
    "    year, month, day = date_string.split('-')\n",
    "    return {'year': int(year), 'month': int(month), 'day': int(day)}\n",
    "\n",
    "# Original division function\n",
    "def divide_two_numbers(a, b):\n",
    "    return a/b\n",
    "\n",
    "# Test Cases\n",
    "print(\"*******************************\")\n",
    "print(\"*******************************\")\n",
    "print(\"** Testing Division Function **\")\n",
    "print(\"*******************************\")\n",
    "print(\"*******************************\")\n",
    "execute_self_healing_code_system(divide_two_numbers, [10, 0]);\n",
    "execute_self_healing_code_system(divide_two_numbers, ['a', 0]);\n",
    "\n",
    "print(\"**************************************\")\n",
    "print(\"**************************************\")\n",
    "print(\"** Testing List Processing Function **\")\n",
    "print(\"**************************************\")\n",
    "print(\"**************************************\")\n",
    "# Test 1: Index out of range\n",
    "execute_self_healing_code_system(process_list, [[1, 2, 3], 5]);\n",
    "# Test 2: Invalid input type\n",
    "execute_self_healing_code_system(process_list, [None, 1]);\n",
    "\n",
    "print(\"***********************************\")\n",
    "print(\"***********************************\")\n",
    "print(\"** Testing Date Parsing Function **\")\n",
    "print(\"***********************************\")\n",
    "print(\"***********************************\")\n",
    "# Test 1: Invalid format\n",
    "execute_self_healing_code_system(parse_date, [\"2024/01/01\"]);\n",
    "# Test 2: Invalid data types\n",
    "execute_self_healing_code_system(parse_date, [\"abc-def-ghi\"]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bdd3789-77e9-47db-8e5d-81e2b1254d24",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
